let THREE=require('three');

export default class HDRLoader extends THREE.DataTextureLoader{
    constructor(manager){
        super(manager);
        this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
        this.type = THREE.UnsignedByteType;
        this._parser=(buffer)=>{

            let
                /* return codes for rgbe routines */
                RGBE_RETURN_SUCCESS = 0,
                RGBE_RETURN_FAILURE = - 1,

                /* default error routine.  change this to change error handling */
                rgbe_read_error = 1,
                rgbe_write_error = 2,
                rgbe_format_error = 3,
                rgbe_memory_error = 4,
                rgbe_error =( rgbe_error_code, msg )=>{

                    switch ( rgbe_error_code ) {

                        case rgbe_read_error: console.error( "THREE.RGBELoader Read Error: " + ( msg || '' ) );
                            break;
                        case rgbe_write_error: console.error( "THREE.RGBELoader Write Error: " + ( msg || '' ) );
                            break;
                        case rgbe_format_error: console.error( "THREE.RGBELoader Bad File Format: " + ( msg || '' ) );
                            break;
                        default:
                        case rgbe_memory_error: console.error( "THREE.RGBELoader: Error: " + ( msg || '' ) );

                    }
                    return RGBE_RETURN_FAILURE;

                },

                /* offsets to red, green, and blue components in a data (float) pixel */
                RGBE_DATA_RED = 0,
                RGBE_DATA_GREEN = 1,
                RGBE_DATA_BLUE = 2,

                /* number of floats per pixel, use 4 since stored in rgba image format */
                RGBE_DATA_SIZE = 4,

                /* flags indicating which fields in an rgbe_header_info are valid */
                RGBE_VALID_PROGRAMTYPE = 1,
                RGBE_VALID_FORMAT = 2,
                RGBE_VALID_DIMENSIONS = 4,

                NEWLINE = "\n",

                fgets = ( buffer, lineLimit, consume ) =>{

                    lineLimit = ! lineLimit ? 1024 : lineLimit;
                    let p = buffer.pos,
                        i = - 1, len = 0, s = '', chunkSize = 128,
                        chunk = String.fromCharCode.apply( null, new Uint16Array( buffer.subarray( p, p + chunkSize ) ) )
                    ;
                    while ( ( 0 > ( i = chunk.indexOf( NEWLINE ) ) ) && ( len < lineLimit ) && ( p < buffer.byteLength ) ) {

                        s += chunk; len += chunk.length;
                        p += chunkSize;
                        chunk += String.fromCharCode.apply( null, new Uint16Array( buffer.subarray( p, p + chunkSize ) ) );

                    }

                    if ( - 1 < i ) {

                        /*for (i=l-1; i>=0; i--) {
                         byteCode = m.charCodeAt(i);
                         if (byteCode > 0x7f && byteCode <= 0x7ff) byteLen++;
                         else if (byteCode > 0x7ff && byteCode <= 0xffff) byteLen += 2;
                         if (byteCode >= 0xDC00 && byteCode <= 0xDFFF) i--; //trail surrogate
                         }*/
                        if ( false !== consume ) buffer.pos += len + i + 1;
                        return s + chunk.slice( 0, i );

                    }
                    return false;

                },

                /* minimal header reading.  modify if you want to parse more information */
                RGBE_ReadHeader = ( buffer )=> {

                    let line, match,

                        // regexes to parse header info fields
                        magic_token_re = /^#\?(\S+)$/,
                        gamma_re = /^\s*GAMMA\s*=\s*(\d+(\.\d+)?)\s*$/,
                        exposure_re = /^\s*EXPOSURE\s*=\s*(\d+(\.\d+)?)\s*$/,
                        format_re = /^\s*FORMAT=(\S+)\s*$/,
                        dimensions_re = /^\s*\-Y\s+(\d+)\s+\+X\s+(\d+)\s*$/,

                        // RGBE format header struct
                        header = {

                            valid: 0, /* indicate which fields are valid */

                            string: '', /* the actual header string */

                            comments: '', /* comments found in header */

                            programtype: 'RGBE', /* listed at beginning of file to identify it after "#?". defaults to "RGBE" */

                            format: '', /* RGBE format, default 32-bit_rle_rgbe */

                            gamma: 1.0, /* image has already been gamma corrected with given gamma. defaults to 1.0 (no correction) */

                            exposure: 1.0, /* a value of 1.0 in an image corresponds to <exposure> watts/steradian/m^2. defaults to 1.0 */

                            width: 0, height: 0 /* image dimensions, width/height */

                        };

                    if ( buffer.pos >= buffer.byteLength || ! ( line = fgets( buffer ) ) ) {

                        return rgbe_error( rgbe_read_error, "no header found" );

                    }
                    /* if you want to require the magic token then uncomment the next line */
                    if ( ! ( match = line.match( magic_token_re ) ) ) {

                        return rgbe_error( rgbe_format_error, "bad initial token" );

                    }
                    header.valid |= RGBE_VALID_PROGRAMTYPE;
                    header.programtype = match[ 1 ];
                    header.string += line + "\n";

                    while ( true ) {

                        line = fgets( buffer );
                        if ( false === line ) break;
                        header.string += line + "\n";

                        if ( '#' === line.charAt( 0 ) ) {

                            header.comments += line + "\n";
                            continue; // comment line

                        }

                        if ( match = line.match( gamma_re ) ) {

                            header.gamma = parseFloat( match[ 1 ], 10 );

                        }
                        if ( match = line.match( exposure_re ) ) {

                            header.exposure = parseFloat( match[ 1 ], 10 );

                        }
                        if ( match = line.match( format_re ) ) {

                            header.valid |= RGBE_VALID_FORMAT;
                            header.format = match[ 1 ];//'32-bit_rle_rgbe';

                        }
                        if ( match = line.match( dimensions_re ) ) {

                            header.valid |= RGBE_VALID_DIMENSIONS;
                            header.height = parseInt( match[ 1 ], 10 );
                            header.width = parseInt( match[ 2 ], 10 );

                        }

                        if ( ( header.valid & RGBE_VALID_FORMAT ) && ( header.valid & RGBE_VALID_DIMENSIONS ) ) break;

                    }

                    if ( ! ( header.valid & RGBE_VALID_FORMAT ) ) {

                        return rgbe_error( rgbe_format_error, "missing format specifier" );

                    }
                    if ( ! ( header.valid & RGBE_VALID_DIMENSIONS ) ) {

                        return rgbe_error( rgbe_format_error, "missing image size specifier" );

                    }

                    return header;

                },

                RGBE_ReadPixels_RLE = ( buffer, w, h )=> {

                    let data_rgba, offset, pos, count, byteValue,
                        scanline_buffer, ptr, ptr_end, i, l, off, isEncodedRun,
                        scanline_width = w, num_scanlines = h, rgbeStart
                    ;

                    if (
                        // run length encoding is not allowed so read flat
                    ( ( scanline_width < 8 ) || ( scanline_width > 0x7fff ) ) ||
                    // this file is not run length encoded
                    ( ( 2 !== buffer[ 0 ] ) || ( 2 !== buffer[ 1 ] ) || ( buffer[ 2 ] & 0x80 ) )
                    ) {

                        // return the flat buffer
                        return new Uint8Array( buffer );

                    }

                    if ( scanline_width !== ( ( buffer[ 2 ] << 8 ) | buffer[ 3 ] ) ) {

                        return rgbe_error( rgbe_format_error, "wrong scanline width" );

                    }

                    data_rgba = new Uint8Array( 4 * w * h );

                    if ( ! data_rgba || ! data_rgba.length ) {

                        return rgbe_error( rgbe_memory_error, "unable to allocate buffer space" );

                    }

                    offset = 0; pos = 0; ptr_end = 4 * scanline_width;
                    rgbeStart = new Uint8Array( 4 );
                    scanline_buffer = new Uint8Array( ptr_end );

                    // read in each successive scanline
                    while ( ( num_scanlines > 0 ) && ( pos < buffer.byteLength ) ) {

                        if ( pos + 4 > buffer.byteLength ) {

                            return rgbe_error( rgbe_read_error );

                        }

                        rgbeStart[ 0 ] = buffer[ pos ++ ];
                        rgbeStart[ 1 ] = buffer[ pos ++ ];
                        rgbeStart[ 2 ] = buffer[ pos ++ ];
                        rgbeStart[ 3 ] = buffer[ pos ++ ];

                        if ( ( 2 != rgbeStart[ 0 ] ) || ( 2 != rgbeStart[ 1 ] ) || ( ( ( rgbeStart[ 2 ] << 8 ) | rgbeStart[ 3 ] ) != scanline_width ) ) {

                            return rgbe_error( rgbe_format_error, "bad rgbe scanline format" );

                        }

                        // read each of the four channels for the scanline into the buffer
                        // first red, then green, then blue, then exponent
                        ptr = 0;
                        while ( ( ptr < ptr_end ) && ( pos < buffer.byteLength ) ) {

                            count = buffer[ pos ++ ];
                            isEncodedRun = count > 128;
                            if ( isEncodedRun ) count -= 128;

                            if ( ( 0 === count ) || ( ptr + count > ptr_end ) ) {

                                return rgbe_error( rgbe_format_error, "bad scanline data" );

                            }

                            if ( isEncodedRun ) {

                                // a (encoded) run of the same value
                                byteValue = buffer[ pos ++ ];
                                for ( i = 0; i < count; i ++ ) {

                                    scanline_buffer[ ptr ++ ] = byteValue;

                                }
                                //ptr += count;

                            } else {

                                // a literal-run
                                scanline_buffer.set( buffer.subarray( pos, pos + count ), ptr );
                                ptr += count; pos += count;

                            }

                        }


                        // now convert data from buffer into rgba
                        // first red, then green, then blue, then exponent (alpha)
                        l = scanline_width; //scanline_buffer.byteLength;
                        for ( i = 0; i < l; i ++ ) {

                            off = 0;
                            data_rgba[ offset ] = scanline_buffer[ i + off ];
                            off += scanline_width; //1;
                            data_rgba[ offset + 1 ] = scanline_buffer[ i + off ];
                            off += scanline_width; //1;
                            data_rgba[ offset + 2 ] = scanline_buffer[ i + off ];
                            off += scanline_width; //1;
                            data_rgba[ offset + 3 ] = scanline_buffer[ i + off ];
                            offset += 4;

                        }

                        num_scanlines --;

                    }

                    return data_rgba;

                }
            ;

            let byteArray = new Uint8Array( buffer ),
                byteLength = byteArray.byteLength;
            byteArray.pos = 0;

            let rgbe_header_info = RGBE_ReadHeader( byteArray );

            if ( RGBE_RETURN_FAILURE !== rgbe_header_info ) {

                let w = rgbe_header_info.width,
                    h = rgbe_header_info.height,
                    image_rgba_data = RGBE_ReadPixels_RLE( byteArray.subarray( byteArray.pos ), w, h )
                ;
                if ( RGBE_RETURN_FAILURE !== image_rgba_data ) {
                    let data,format,type;

                    if ( this.type === THREE.UnsignedByteType ) {

                        data = image_rgba_data;
                        format = THREE.RGBEFormat; // handled as THREE.RGBAFormat in shaders
                        type = THREE.UnsignedByteType;

                    } else if ( this.type === THREE.FloatType ) {

                        let RGBEByteToRGBFloat =  ( sourceArray, sourceOffset, destArray, destOffset )=> {

                            let e = sourceArray[ sourceOffset + 3 ];
                            let scale = Math.pow( 2.0, e - 128.0 ) / 255.0;

                            destArray[ destOffset + 0 ] = sourceArray[ sourceOffset + 0 ] * scale;
                            destArray[ destOffset + 1 ] = sourceArray[ sourceOffset + 1 ] * scale;
                            destArray[ destOffset + 2 ] = sourceArray[ sourceOffset + 2 ] * scale;

                        };

                        let numElements = ( image_rgba_data.length / 4 ) * 3;
                        let floatArray = new Float32Array( numElements );

                        for ( let j = 0; j < numElements; j ++ ) {

                            RGBEByteToRGBFloat( image_rgba_data, j * 4, floatArray, j * 3 );

                        }

                        data = floatArray;
                        format = THREE.RGBFormat;
                        type = THREE.FloatType;


                    } else {

                        console.error( 'THREE.RGBELoader: unsupported type: ', this.type );

                    }

                    return {
                        width: w, height: h,
                        data: data,
                        header: rgbe_header_info.string,
                        gamma: rgbe_header_info.gamma,
                        exposure: rgbe_header_info.exposure,
                        format: format,
                        type: type
                    };

                }

            }

            return null;
        };
        this.setType=( value )=> {
            this.type = value;
            return this;
        };
    }
}
